"""
主应用GUI界面

基于Tkinter的完整素材库管理系统，包含左侧菜单和多功能页面
采用统一的设计系统规范
"""

import tkinter as tk
from tkinter import ttk, messagebox
import os
from pathlib import Path
from typing import Dict, Any, Optional

# 导入设计系统
from .design_system import DesignSystem, create_card_frame, create_primary_button


class MainApplication:
    """主应用程序类"""

    def __init__(self):
        self.root = tk.Tk()
        self.root.title("🎬 短视频混剪工具")
        self.root.geometry("1400x900")
        self.root.minsize(1000, 700)

        # 设置图标和背景
        self.root.configure(bg=DesignSystem.COLORS["bg_primary"])

        # 设置统一的设计系统主题
        self.style = DesignSystem.setup_styles(self.root)

        # 当前页面
        self.current_page = None
        self.pages = {}

        # 创建主界面
        self.create_main_layout()

        # 默认显示工作台页面
        self.show_page("dashboard")

    # setup_theme 方法已被 DesignSystem.setup_styles 替代，删除此方法

    def create_main_layout(self):
        """创建主布局"""
        # 创建顶部菜单栏
        self.create_menubar()

        # 主容器
        main_container = ttk.Frame(self.root)
        main_container.pack(fill="both", expand=True)

        # 左侧菜单
        self.create_sidebar(main_container)

        # 右侧内容区域
        self.create_content_area(main_container)

    def create_menubar(self):
        """创建顶部菜单栏"""
        # 创建主菜单栏
        menubar = tk.Menu(self.root)

        # 任务管理菜单
        task_menu = tk.Menu(menubar, tearoff=0)
        task_menu.add_command(label="📋 任务列表", command=self.open_task_list)
        task_menu.add_command(label="🎬 触发混剪任务", command=self.open_trigger_task)
        task_menu.add_separator()
        task_menu.add_command(label="📊 任务统计", command=self.show_task_statistics)
        menubar.add_cascade(label="📋 任务管理", menu=task_menu)

        # 素材管理菜单
        material_menu = tk.Menu(menubar, tearoff=0)
        material_menu.add_command(label="📋 素材列表", command=self.open_material_list)
        material_menu.add_command(label="➕ 添加素材", command=self.open_add_material)
        material_menu.add_separator()
        material_menu.add_command(label="🔍 搜索素材", command=self.search_materials)
        material_menu.add_command(
            label="📥 批量导入", command=self.batch_import_materials
        )
        menubar.add_cascade(label="📁 素材管理", menu=material_menu)

        # 商品管理菜单
        product_menu = tk.Menu(menubar, tearoff=0)
        product_menu.add_command(label="📦 商品列表", command=self.open_product_list)
        product_menu.add_command(label="➕ 添加商品", command=self.open_add_product)
        product_menu.add_command(
            label="🏷️ 分类管理", command=self.open_category_management
        )
        product_menu.add_separator()
        product_menu.add_command(
            label="📊 商品统计", command=self.show_product_statistics
        )
        menubar.add_cascade(label="🏪 商品管理", menu=product_menu)

        # 工作流管理菜单
        workflow_menu = tk.Menu(menubar, tearoff=0)
        workflow_menu.add_command(
            label="🔄 工作流列表", command=self.open_workflow_list
        )
        workflow_menu.add_command(label="➕ 创建工作流", command=self.create_workflow)
        workflow_menu.add_separator()
        workflow_menu.add_command(label="⚙️ 工作流设置", command=self.workflow_settings)
        menubar.add_cascade(label="🔄 工作流管理", menu=workflow_menu)

        # 模板管理菜单
        template_menu = tk.Menu(menubar, tearoff=0)
        template_menu.add_command(
            label="🎨 模板库列表", command=self.open_template_library
        )
        template_menu.add_command(
            label="📥 导入模板库", command=self.open_import_template
        )
        template_menu.add_separator()
        template_menu.add_command(label="🔍 搜索模板", command=self.search_templates)
        menubar.add_cascade(label="🎨 模板管理", menu=template_menu)

        # 系统设置菜单
        system_menu = tk.Menu(menubar, tearoff=0)
        system_menu.add_command(label="⚙️ 系统设置", command=self.open_system_settings)
        system_menu.add_command(label="👤 用户管理", command=self.user_management)
        system_menu.add_separator()
        system_menu.add_command(
            label="📊 系统统计", command=self.show_system_statistics
        )
        system_menu.add_command(label="🔧 系统诊断", command=self.system_diagnosis)
        system_menu.add_separator()
        system_menu.add_command(label="❓ 帮助文档", command=self.show_help)
        system_menu.add_command(label="ℹ️ 关于系统", command=self.show_about)
        menubar.add_cascade(label="⚙️ 系统设置", menu=system_menu)

        # 将菜单栏配置到窗口
        self.root.config(menu=menubar)

    def create_sidebar(self, parent):
        """创建左侧菜单"""
        # 侧边栏容器 - 调整为合理宽度
        sidebar_frame = ttk.Frame(parent, style="Sidebar.TFrame", width=200)
        sidebar_frame.pack(side="left", fill="y")
        sidebar_frame.pack_propagate(False)





        # 菜单项
        self.create_menu_items(sidebar_frame)

        # 底部信息
        self.create_sidebar_footer(sidebar_frame)

    def create_menu_items(self, parent):
        """创建菜单项"""
        # 创建可滚动的菜单容器
        menu_container = ttk.Frame(parent, style="Sidebar.TFrame")
        menu_container.pack(
            fill="both",
            expand=True,
            padx=DesignSystem.SPACING["lg"],
            pady=DesignSystem.SPACING["md"],
        )

        # 创建Canvas和Scrollbar用于滚动
        self.menu_canvas = tk.Canvas(
            menu_container, bg=DesignSystem.COLORS["bg_sidebar"], highlightthickness=0
        )
        menu_scrollbar = ttk.Scrollbar(
            menu_container, orient="vertical", command=self.menu_canvas.yview
        )
        self.menu_canvas.configure(yscrollcommand=menu_scrollbar.set)

        # 创建实际的菜单框架
        menu_frame = ttk.Frame(self.menu_canvas, style="Sidebar.TFrame")

        # 将菜单框架添加到Canvas中
        self.menu_canvas_window = self.menu_canvas.create_window(
            (0, 0), window=menu_frame, anchor="nw"
        )

        # 布局Canvas和滚动条
        self.menu_canvas.pack(side="left", fill="both", expand=True)
        menu_scrollbar.pack(side="right", fill="y")

        # 绑定鼠标滚轮事件 - 使用更直接的方法
        self.setup_mousewheel_scrolling()

        # 绑定配置事件以更新滚动区域
        menu_frame.bind("<Configure>", self.on_menu_frame_configure)
        self.menu_canvas.bind("<Configure>", self.on_canvas_configure)

        # 重新设计的左侧导航 - 简化版本，配合顶部菜单栏
        menu_groups = [
            {"text": "🏠 工作台", "page": "dashboard"},
            {"text": "📁 素材管理", "page": "material_list"},
            {"text": "🎨 模板管理", "page": "template_library"},
        ]

        self.menu_buttons = {}

        # 创建简化的扁平菜单 - 图标+文字靠左显示，带激活指示器
        for item in menu_groups:
            # 创建菜单项容器
            menu_item_frame = ttk.Frame(menu_frame, style="Sidebar.TFrame")
            menu_item_frame.pack(fill="x", pady=DesignSystem.SPACING["xs"])

            # 左侧激活指示器 (初始隐藏)
            indicator = tk.Frame(
                menu_item_frame,
                width=3,
                bg=DesignSystem.COLORS['primary'],
                relief='flat'
            )
            indicator.pack(side="left", fill="y")
            indicator.pack_forget()  # 初始隐藏

            # 菜单按钮 - 靠左对齐
            btn = ttk.Button(
                menu_item_frame,
                text=item["text"],
                style="SidebarButton.TButton",
                command=lambda page=item["page"]: self.show_page(page),
            )
            btn.pack(side="left", fill="x", expand=True, padx=DesignSystem.SPACING["sm"])

            # 存储按钮和指示器的引用
            self.menu_buttons[item["page"]] = {
                'button': btn,
                'indicator': indicator,
                'container': menu_item_frame
            }

    def create_sidebar_footer(self, parent):
        """创建侧边栏底部"""
        footer_frame = ttk.Frame(parent, style="Sidebar.TFrame")
        footer_frame.pack(
            side="bottom",
            fill="x",
            padx=DesignSystem.SPACING["xl"],
            pady=DesignSystem.SPACING["xl"],
        )

        # 分隔线
        separator = ttk.Separator(footer_frame, orient="horizontal")
        separator.pack(fill="x", pady=(0, DesignSystem.SPACING["md"]))

        # 版本信息
        version_label = ttk.Label(
            footer_frame, text="版本 1.0.0", style="SidebarText.TLabel"
        )
        version_label.pack()

        # 状态信息
        status_label = ttk.Label(
            footer_frame, text="● 系统正常", style="SidebarText.TLabel"
        )
        status_label.pack(pady=(DesignSystem.SPACING["xs"], 0))

    def setup_mousewheel_scrolling(self):
        """设置鼠标滚轮滚动功能"""

        def on_mousewheel(event):
            # 检查Canvas是否存在
            if hasattr(self, "menu_canvas") and self.menu_canvas.winfo_exists():
                try:
                    # 根据不同平台处理滚轮事件
                    if hasattr(event, "delta") and event.delta:
                        # Windows和macOS
                        delta = -1 * (event.delta / 120)
                    elif hasattr(event, "num"):
                        # Linux
                        if event.num == 4:
                            delta = -1
                        elif event.num == 5:
                            delta = 1
                        else:
                            return
                    else:
                        return

                    # 执行滚动
                    self.menu_canvas.yview_scroll(int(delta), "units")
                except Exception as e:
                    print(f"滚轮滚动错误: {e}")

        # 为整个应用程序绑定滚轮事件
        def bind_mousewheel_to_widget(widget):
            """递归绑定滚轮事件到widget及其子组件"""
            try:
                widget.bind("<MouseWheel>", on_mousewheel)  # Windows/macOS
                widget.bind("<Button-4>", on_mousewheel)  # Linux向上
                widget.bind("<Button-5>", on_mousewheel)  # Linux向下

                # 递归绑定到所有子组件
                for child in widget.winfo_children():
                    bind_mousewheel_to_widget(child)
            except Exception:
                pass  # 忽略绑定错误

        # 延迟绑定，确保所有组件都已创建
        def delayed_bind():
            try:
                # 绑定到侧边栏
                if hasattr(self, "sidebar_frame"):
                    bind_mousewheel_to_widget(self.sidebar_frame)

                # 绑定到Canvas
                if hasattr(self, "menu_canvas"):
                    bind_mousewheel_to_widget(self.menu_canvas)

                # 绑定到根窗口
                bind_mousewheel_to_widget(self.root)

            except Exception as e:
                print(f"延迟绑定滚轮事件失败: {e}")

        # 延迟执行绑定
        self.root.after(300, delayed_bind)

    def on_menu_frame_configure(self, event):
        """菜单框架配置改变时更新滚动区域"""
        # 更新Canvas的滚动区域
        self.menu_canvas.configure(scrollregion=self.menu_canvas.bbox("all"))

        # 更新Canvas窗口的宽度以匹配Canvas宽度
        canvas_width = self.menu_canvas.winfo_width()
        if canvas_width > 1:  # 确保Canvas已经被渲染
            self.menu_canvas.itemconfig(self.menu_canvas_window, width=canvas_width)

    def on_canvas_configure(self, event):
        """Canvas配置改变时更新菜单框架宽度"""
        # 更新菜单框架的宽度以匹配Canvas宽度
        canvas_width = event.width
        self.menu_canvas.itemconfig(self.menu_canvas_window, width=canvas_width)

    def create_content_area(self, parent):
        """创建内容区域"""
        # 内容容器 - 添加内边距和背景
        self.content_frame = ttk.Frame(
            parent, style="TFrame", padding=DesignSystem.SPACING["xl"]
        )
        self.content_frame.pack(side="right", fill="both", expand=True)

        # 创建各个页面
        self.create_pages()

    def create_pages(self):
        """创建所有页面"""
        # 导入页面类
        from .pages.dashboard_page import DashboardPage
        from .pages.material_list_page import MaterialListPage
        from .pages.add_material_page import AddMaterialPage
        from .pages.category_management_page import CategoryManagementPage
        from .pages.add_product_page import AddProductPage
        from .pages.product_list_page import ProductListPage
        from .pages.task_list_page import TaskListPage
        from .pages.trigger_task_page import TriggerTaskPage
        from .pages.statistics_page import StatisticsPage
        from .pages.template_library_page import TemplateLibraryPage
        from .pages.import_template_page import ImportTemplatePage
        from .pages.output_management_page import OutputManagementPage
        from .pages.output_schedule_page import OutputSchedulePage
        from .pages.settings_page import SettingsPage

        # 创建页面实例
        self.pages = {
            # 工作台
            "dashboard": DashboardPage(self.content_frame, self),
            # 素材库管理
            "material_list": MaterialListPage(self.content_frame, self),
            "add_material": AddMaterialPage(self.content_frame, self),
            # 商品管理
            "category_management": CategoryManagementPage(self.content_frame, self),
            "add_product": AddProductPage(self.content_frame, self),
            "product_list": ProductListPage(self.content_frame, self),
            # 任务管理
            "task_list": TaskListPage(self.content_frame, self),
            "trigger_task": TriggerTaskPage(self.content_frame, self),
            # 数据统计
            "statistics": StatisticsPage(self.content_frame, self),
            # 模板库管理
            "template_library": TemplateLibraryPage(self.content_frame, self),
            "import_template": ImportTemplatePage(self.content_frame, self),
            # 成品管理
            "output_management": OutputManagementPage(self.content_frame, self),
            "output_schedule": OutputSchedulePage(self.content_frame, self),
            # 系统设置
            "settings": SettingsPage(self.content_frame, self),
        }

    def show_page(self, page_name: str):
        """显示指定页面"""
        # 隐藏当前页面
        if self.current_page:
            self.pages[self.current_page].hide()

        # 更新菜单按钮样式
        self.update_menu_buttons(page_name)

        # 显示新页面
        if page_name in self.pages:
            self.pages[page_name].show()
            self.current_page = page_name
        else:
            messagebox.showwarning("提示", f"页面 {page_name} 开发中...")

    def update_menu_buttons(self, active_page: str):
        """更新菜单按钮样式 - 优化激活状态，带指示器"""
        for page, menu_item in self.menu_buttons.items():
            button = menu_item['button']
            indicator = menu_item['indicator']

            if page == active_page:
                # 设置激活状态样式
                button.configure(style="SidebarButtonActive.TButton")
                # 显示左侧激活指示器
                indicator.pack(side="left", fill="y", before=button)
            else:
                # 恢复普通状态样式
                button.configure(style="SidebarButton.TButton")
                # 隐藏左侧激活指示器
                indicator.pack_forget()

    def refresh_current_page(self):
        """刷新当前页面"""
        if self.current_page and self.current_page in self.pages:
            self.pages[self.current_page].refresh()

    def get_current_page(self) -> Optional[str]:
        """获取当前页面名称"""
        return self.current_page

    def run(self):
        """运行应用程序"""
        # 设置窗口关闭事件
        self.root.protocol("WM_DELETE_WINDOW", self.on_closing)

        # 启动主循环
        self.root.mainloop()

    def on_closing(self):
        """窗口关闭事件"""
        if messagebox.askokcancel("退出", "确定要退出应用程序吗？"):
            self.root.destroy()

    # 菜单事件处理方法

    # 任务管理相关
    def open_task_list(self):
        """打开任务列表"""
        self.show_page("task_list")

    def open_trigger_task(self):
        """打开触发任务"""
        self.show_page("trigger_task")

    def show_task_statistics(self):
        """显示任务统计"""
        self.show_page("statistics")

    # 素材管理相关
    def open_material_list(self):
        """打开素材列表"""
        self.show_page("material_list")

    def open_add_material(self):
        """打开添加素材"""
        self.show_page("add_material")

    def search_materials(self):
        """搜索素材"""
        messagebox.showinfo("搜索素材", "素材搜索功能开发中...")

    def batch_import_materials(self):
        """批量导入素材"""
        messagebox.showinfo("批量导入", "批量导入素材功能开发中...")

    # 商品管理相关
    def open_product_list(self):
        """打开商品列表"""
        self.show_page("product_list")

    def open_add_product(self):
        """打开添加商品"""
        self.show_page("add_product")

    def open_category_management(self):
        """打开分类管理"""
        self.show_page("category_management")

    def show_product_statistics(self):
        """显示商品统计"""
        self.show_page("statistics")

    # 工作流管理相关
    def open_workflow_list(self):
        """打开工作流列表"""
        messagebox.showinfo("工作流列表", "工作流列表功能开发中...")

    def create_workflow(self):
        """创建工作流"""
        messagebox.showinfo("创建工作流", "创建工作流功能开发中...")

    def workflow_settings(self):
        """工作流设置"""
        messagebox.showinfo("工作流设置", "工作流设置功能开发中...")

    # 模板管理相关
    def open_template_library(self):
        """打开模板库"""
        self.show_page("template_library")

    def open_import_template(self):
        """打开导入模板"""
        self.show_page("import_template")

    def search_templates(self):
        """搜索模板"""
        messagebox.showinfo("搜索模板", "模板搜索功能开发中...")

    # 系统设置相关
    def open_system_settings(self):
        """打开系统设置"""
        self.show_page("settings")

    def user_management(self):
        """用户管理"""
        messagebox.showinfo("用户管理", "用户管理功能开发中...")

    def show_system_statistics(self):
        """显示系统统计"""
        self.show_page("statistics")

    def system_diagnosis(self):
        """系统诊断"""
        messagebox.showinfo("系统诊断", "系统诊断功能开发中...")

    def show_help(self):
        """显示帮助"""
        messagebox.showinfo("帮助文档", "帮助文档功能开发中...")

    def show_about(self):
        """显示关于"""
        messagebox.showinfo(
            "关于系统",
            "🎬 视频混剪系统 v1.0\n\n"
            "专业的短视频混剪工具\n"
            "支持任务管理、素材管理、商品管理等功能\n\n"
            "© 2024 视频混剪系统",
        )


class BasePage:
    """页面基类"""

    def __init__(self, parent, app):
        self.parent = parent
        self.app = app
        self.frame = None
        self.is_created = False

    def create_page(self):
        """创建页面内容 - 子类需要实现"""
        raise NotImplementedError("子类必须实现 create_page 方法")

    def show(self):
        """显示页面"""
        if not self.is_created:
            self.create_page()
            self.is_created = True

        if self.frame:
            self.frame.pack(fill="both", expand=True, padx=20, pady=20)

    def hide(self):
        """隐藏页面"""
        if self.frame:
            self.frame.pack_forget()

    def refresh(self):
        """刷新页面 - 子类可以重写"""
        pass


def main():
    """主函数"""
    app = MainApplication()
    app.run()


if __name__ == "__main__":
    main()
